﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using Microsoft.Xna.Framework;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using GestionEco;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using System.Drawing;
using System.IO;
using System.Threading;

namespace Ecosystème
{
    public static class Traitements
    {

        public static List<EtreVivant> laListeEcosysteme;
        public static Plateau lePlateau;
        public static int[] taille;
        public static List<Plateau> laListePlateau;
        private static Random rand = new Random();
        public static int nbTours;
        public static int tourCourant;
        public static int indexDeIndividusCourant;
        public static bool start;
        public static int[] tabValeur;
        public static GraphicsDevice graphicDevice;
        public static DataGridView dgvA;
        public static DataGridView dgvV;


        public static void chargerVegetaux(DataGridView vegetaux)
        {
            dgvV = vegetaux;
            int i = 0;

            if (Convert.ToBoolean(dgvV.Rows[0].Cells["presentV"].Value) == true)
            {
                while (i < Convert.ToInt32(dgvV.Rows[0].Cells["nbrV"].Value))
                {
                    if (i % 2 == 0)
                    {
                        laListeEcosysteme.Add(new Cactus(true, 5, 10, 1, 6, 10, 2, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\cactus.png")));
                    }
                    else
                    {
                        laListeEcosysteme.Add(new Cactus(false, 5, 10, 1, 6, 10, 2, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\cactus.png")));
                    }
                    i++;
                }
                i = 0;
            }

            if (Convert.ToBoolean(dgvV.Rows[1].Cells["presentV"].Value) == true)
            {
                while (i < Convert.ToInt32(dgvV.Rows[1].Cells["nbrV"].Value))
                {
                    if (i % 2 == 0)
                    {
                        laListeEcosysteme.Add(new Tulipe(true, 5, 10, 1, 6, 10, 2, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\tulipe.png")));
                    }
                    else
                    {
                        laListeEcosysteme.Add(new Tulipe(false, 5, 10, 1, 6, 10, 2, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\tulipe.png")));
                    }
                    i++;
                }
                i = 0;
            }
        }

        public static void chargerAnimaux(DataGridView animaux)
        {
            dgvA = animaux;
            int i = 0;

            if (Convert.ToBoolean(dgvA.Rows[0].Cells["presentA"].Value) == true)
            {
                while (i < Convert.ToInt32(dgvA.Rows[0].Cells["nbrA"].Value))
                {
                    if (i % 2 == 0)
                    {
                        laListeEcosysteme.Add(new Chameau(true, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\chameau.png")));
                    }
                    else
                    {
                        laListeEcosysteme.Add(new Chameau(false, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\chameau.png")));
                    }
                    i++;
                }
                i = 0;
            }

            if (Convert.ToBoolean(dgvA.Rows[1].Cells["presentA"].Value) == true)
            {
                while (i < Convert.ToInt32(dgvA.Rows[1].Cells["nbrA"].Value))
                {
                    if (i % 2 == 0)
                    {
                        laListeEcosysteme.Add(new Chat(true, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\chat.png")));
                    }
                    else
                    {
                        laListeEcosysteme.Add(new Chat(false, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\chat.png")));
                    }
                    i++;
                }
                i = 0;
            }

            if (Convert.ToBoolean(dgvA.Rows[2].Cells["presentA"].Value) == true)
            {
                while (i < Convert.ToInt32(dgvA.Rows[2].Cells["nbrA"].Value))
                {
                    if (i % 2 == 0)
                    {
                        laListeEcosysteme.Add(new Chevre(true, 1, 5, 2, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\chevre.png")));
                    }
                    else
                    {
                        laListeEcosysteme.Add(new Chevre(false, 1, 5, 2, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\chevre.png")));
                    }
                    i++;
                }
                i = 0;
            }

            if (Convert.ToBoolean(dgvA.Rows[3].Cells["presentA"].Value) == true)
            {
                while (i < Convert.ToInt32(dgvA.Rows[3].Cells["nbrA"].Value))
                {
                    if (i % 2 == 0)
                    {
                        laListeEcosysteme.Add(new Chien(true, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\chien.png")));
                    }
                    else
                    {
                        laListeEcosysteme.Add(new Chien(false, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\chien.png")));
                    }
                    i++;
                }
                i = 0;
            }

            if (Convert.ToBoolean(dgvA.Rows[4].Cells["presentA"].Value) == true)
            {
                while (i < Convert.ToInt32(dgvA.Rows[4].Cells["nbrA"].Value))
                {
                    if (i % 2 == 0)
                    {
                        laListeEcosysteme.Add(new Loup(true, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\loup.png")));
                    }
                    else
                    {
                        laListeEcosysteme.Add(new Loup(false, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\loup.png")));
                    }
                    i++;
                }
                i = 0;
            }

            if (Convert.ToBoolean(dgvA.Rows[5].Cells["presentA"].Value) == true)
            {
                while (i < Convert.ToInt32(dgvA.Rows[5].Cells["nbrA"].Value))
                {
                    if (i % 2 == 0)
                    {
                        laListeEcosysteme.Add(new Pigeon(true, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\pigeon.png")));
                    }
                    else
                    {
                        laListeEcosysteme.Add(new Pigeon(false, 100, 5, 8, 2, 6, 7, 200, 20, 200, 20, 6, 20, 5, 2, System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\EtreVivants\pigeon.png")));
                    }
                    i++;
                }
                i = 0;
            }
        }

        public static void initialisation(ContentManager leContent)
        {
            start = false;
            nbTours = 100;
            tourCourant = 1;
            laListeEcosysteme = new List<EtreVivant>();
            lePlateau = new Plateau();
            int i = 0;

            chargerAnimaux(dgvA);
            chargerVegetaux(dgvV);

            //Transformation des images en textures
            //Génération des terrains

            for (i = 0; i < taille[0]; i++)
            {
                lePlateau.LesCases.Add(new List<Case>());
                for (int j = 0; j < taille[1]; j++)
                {
                    switch (rand.Next(0, 5))
                    {
                        case 1:
                            lePlateau.LesCases[i].Add(new Case(System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\Mer.jpg"), "Mer"));
                            break;
                        case 2:
                            lePlateau.LesCases[i].Add(new Case(System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\Plaine.jpg"), "Plaine"));
                            break;
                        case 3:
                            lePlateau.LesCases[i].Add(new Case(System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\Foret.jpg"), "Forêt"));
                            break;
                        case 4:
                            lePlateau.LesCases[i].Add(new Case(System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\Montagne.jpg"), "Montagne"));
                            break;
                        default:
                            lePlateau.LesCases[i].Add(new Case(System.Drawing.Image.FromFile(Application.StartupPath + @"\Content\Desert.jpg"), "Désert"));
                            break;
                    }
                }
            }

            //Association des etres vivants aux cases et gestion si apparait sur la mer
            foreach (EtreVivant ev in laListeEcosysteme)
            {
                int x;
                int y;
                x = rand.Next(0, taille[0] - 1);
                y = rand.Next(0, taille[1] - 1);
                lePlateau.LesCases.ElementAt(x).ElementAt(y).ListEVCase.Add(ev);

                while (lePlateau.LesCases.ElementAt(x).ElementAt(y).Terrain.Type == "Mer")
                {
                    lePlateau.LesCases.ElementAt(x).ElementAt(y).ListEVCase.Remove(ev);
                    x = rand.Next(0, taille[0] - 1);
                    y = rand.Next(0, taille[1] - 1);
                    lePlateau.LesCases.ElementAt(x).ElementAt(y).ListEVCase.Add(ev);
                }
            }

            indexDeIndividusCourant = 0;
            Console.WriteLine("------------------------------ Tour actuel : " + tourCourant + " ----------------------------------------------------");

        }

        public static void actionEtreVivant(List<string> actionDialog)
        {
            if(actionDialog.Count >0)
 	            actionDialog.RemoveRange(0, actionDialog.Count - 1); 
            // IAAAAAAAA
            if (indexDeIndividusCourant >= laListeEcosysteme.Count)
            {
                indexDeIndividusCourant = 0;
                tourCourant++;
                actionDialog.Add("------------------------------ Tour actuel : " + tourCourant + " ----------------------------------------------------");

                foreach (List<Case> C1 in Traitements.lePlateau.LesCases)
                {
                    foreach (Case C2 in C1)
                    {
                        C2.Terrain.QteEauActuelle = C2.Terrain.Humidite;
                    }
                }
                foreach (EtreVivant ev in Traitements.laListeEcosysteme)
                {
                    ev.PointsActionActuels = 6;
                }
                Traitements.laListePlateau.Add(Traitements.lePlateau);
                if (Traitements.laListePlateau.Count > 4)
                    Traitements.laListePlateau.RemoveAt(0);
            }

            Boolean etat = false;
            int prioriteFaim = 0;
            int prioriteSoif = 0;
            int prioriteReproduction = 0;


            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            etat = miseAjourEtat(actionDialog);

            if (etat == true)
            {

                prioriteSoif = definirPrioriteSoif();
                prioriteReproduction = definirPrioriteReproduction();
                if (etreVivantEnCours.GetType().BaseType.Name.ToString().Equals("Vegetal") == false)
                {
                    prioriteFaim = definirPrioriteFaim();
                }







                // IAAAAAAAAAAAAAAAAAAA
                // IAAAAAAAAAAAAAAAAAAA
                if (etreVivantEnCours.GetType().BaseType.Name.ToString().Equals("Vegetal") == false)
                {
                    deplacerUnIndividus(actionDialog);
                }
                // etreVivantEnCours.retraitPoints(1);



                // ---------------------------Test reprod -------------------------------
                // ---------------------------Test reprod -------------------------------
                // ---------------------------Test reprod -------------------------------
                // ---------------------------Test reprod -------------------------------

                Case cas = etreVivantEnCours.CasePosition;
                if (etreVivantEnCours.GetType().BaseType.Name.ToString().Equals("Vegetal") == false)
                {
                    foreach (EtreVivant ev in cas.ListEVCase)
                    {
                        if ((ev.GetType() == etreVivantEnCours.GetType()) && (ev.Sexe != etreVivantEnCours.Sexe) && (ev.PointsActionActuels == 6))
                        {
                            EtreVivant enfant;
                            enfant = etreVivantEnCours.seReproduire(ev);
                            actionDialog.Add("reproduction");
                            System.Drawing.Image im = enfant.ImageEtre;
                            //On resize l'image
                            Bitmap img = new Bitmap(im, new Size(100, 100));
                            using (MemoryStream s = new MemoryStream())
                            {

                                img.Save(s, System.Drawing.Imaging.ImageFormat.Png);
                                s.Seek(0, SeekOrigin.Begin);
                                // Ajout de l'image sur la texture de l'être vivant
                                enfant.Texture = Texture2D.FromStream(graphicDevice, s);
                            }
                            laListeEcosysteme.Add(enfant);
                            cas.ListEVCase.Add(enfant);
                        }
                        break;
                    }
                }

                // reprod plantes

                if (etreVivantEnCours.GetType().BaseType.Name.ToString().Equals("Vegetal") == true)
                {
                    int distance;
                    distance = etreVivantEnCours.Vue * 400 - 400;
                    List<EtreVivant> laListeReprod = new List<EtreVivant>();
                    Vector2 posi;
                    Vector2 temp;
                    posi.X = etreVivantEnCours.CasePosition.Position.X;
                    posi.Y = etreVivantEnCours.CasePosition.Position.Y;
                    posi.X -= distance;
                    if (posi.X < 0)
                    {
                        posi.X = 0;
                    }

                    posi.Y -= distance;
                    if (posi.Y < 0)
                    {
                        posi.Y = 0;
                    }

                    temp = posi;
                    Case caseReprod = etreVivantEnCours.CasePosition;

                    while (posi.X <= etreVivantEnCours.CasePosition.Position.X + distance)
                    {
                        if (posi.X <= (taille[0] * 400 - 400))
                        {
                            while (posi.Y <= etreVivantEnCours.CasePosition.Position.Y + distance)
                            {
                                if (posi.Y <= (taille[1] * 400 - 400))
                                {
                                    caseReprod.Position = posi;
                                    foreach (EtreVivant ev in caseReprod.ListEVCase)
                                    {
                                        if ((ev.GetType() == etreVivantEnCours.GetType()) && (ev.PointsActionActuels >= 6) && (ev.Sexe != etreVivantEnCours.Sexe))
                                        {
                                            laListeReprod.Add(ev);
                                        }
                                    }
                                }
                                posi.Y = posi.Y + 400;
                            }
                            posi.Y = temp.Y;
                        }
                        posi.X = posi.X + 400;
                    }


                    if (laListeReprod.Count > 0)
                    {
                        Random rnd = new Random();
                        EtreVivant enfant;
                        EtreVivant parent2;
                        parent2 = laListeReprod.ElementAt(rnd.Next(0, laListeReprod.Count));
                        enfant = etreVivantEnCours.seReproduire(parent2);
                        actionDialog.Add("reproduction");
                        System.Drawing.Image im = enfant.ImageEtre;
                        //On resize l'image
                        Bitmap img = new Bitmap(im, new Size(100, 100));
                        using (MemoryStream s = new MemoryStream())
                        {

                            img.Save(s, System.Drawing.Imaging.ImageFormat.Png);
                            s.Seek(0, SeekOrigin.Begin);
                            // Ajout de l'image sur la texture de l'être vivant
                            enfant.Texture = Texture2D.FromStream(graphicDevice, s);
                        }
                        laListeEcosysteme.Add(enfant);


                        List<Vector2> posiPossible = new List<Vector2>();
                        List<Vector2> vueParent1 = new List<Vector2>();
                        List<Vector2> vueParent2 = new List<Vector2>();

                        posi.X = etreVivantEnCours.CasePosition.Position.X;
                        posi.Y = etreVivantEnCours.CasePosition.Position.Y;
                        posi.X -= distance;
                        if (posi.X < 0)
                        {
                            posi.X = 0;
                        }

                        posi.Y -= distance;
                        if (posi.Y < 0)
                        {
                            posi.Y = 0;
                        }

                        temp = posi;

                        while (posi.X <= etreVivantEnCours.CasePosition.Position.X + distance)
                        {
                            if (posi.X <= (taille[0] * 400 - 400))
                            {
                                while (posi.Y <= etreVivantEnCours.CasePosition.Position.Y + distance)
                                {
                                    if (posi.Y <= (taille[1] * 400 - 400))
                                    {
                                        vueParent1.Add(posi);
                                    }
                                    posi.Y = posi.Y + 400;
                                }
                                posi.Y = temp.Y;
                            }
                            posi.X = posi.X + 400;
                        }


                        posi.X = etreVivantEnCours.CasePosition.Position.X;
                        posi.Y = etreVivantEnCours.CasePosition.Position.Y;
                        posi.X -= distance;
                        if (posi.X < 0)
                        {
                            posi.X = 0;
                        }

                        posi.Y -= distance;
                        if (posi.Y < 0)
                        {
                            posi.Y = 0;
                        }

                        temp = posi;

                        while (posi.X <= parent2.CasePosition.Position.X + distance)
                        {
                            if (posi.X <= (taille[0] * 400 - 400))
                            {
                                while (posi.Y <= parent2.CasePosition.Position.Y + distance)
                                {
                                    if (posi.Y <= (taille[1] * 400 - 400))
                                    {
                                        vueParent2.Add(posi);
                                    }
                                    posi.Y = posi.Y + 400;
                                }
                                posi.Y = temp.Y;
                            }
                            posi.X = posi.X + 400;
                        }

                        for (int i = 0; i < vueParent1.Count; i++)
                        {
                            for (int j = 0; j < vueParent2.Count; j++)
                            {
                                if (vueParent1.ElementAt(i) == vueParent2.ElementAt(j))
                                {
                                    posiPossible.Add(vueParent1.ElementAt(i));
                                }
                            }
                        }

                        posi = posiPossible.ElementAt(rnd.Next(1, posiPossible.Count));

                        cas.Position = posi;
                        cas.ListEVCase.Add(enfant);

                    }
                }

                // ---------------------------Test reprod -------------------------------
                // ---------------------------Test reprod -------------------------------
                // ---------------------------Test reprod -------------------------------
                // ---------------------------Test reprod -------------------------------





                // --------------------- test a modifier ----------------
                // --------------------- test a modifier ----------------
                // --------------------- test a modifier ----------------
                // --------------------- test a modifier ----------------

                if (Convert.ToString(etreVivantEnCours.GetType().BaseType) == "GestionEco.Carnivore")
                {

                    // ------------------- a decommenter !!!!!!!! ------------------
                    // ------------------- a decommenter !!!!!!!! ------------------
                    // ------------------- a decommenter !!!!!!!! ------------------

                    trouverUneCible();

                    // ------------------- a decommenter !!!!!!!! ------------------
                    // ------------------- a decommenter !!!!!!!! ------------------
                    // ------------------- a decommenter !!!!!!!! ------------------
                    Case cases = etreVivantEnCours.CasePosition;
                    foreach (EtreVivant ev in cases.ListEVCase)
                    {
                        if (Convert.ToString(ev.GetType().BaseType) == "GestionEco.Herbivore" && ev.GetType().Name.ToString().Equals(etreVivantEnCours.EspeceFavorite))
                        {
                            Console.WriteLine(etreVivantEnCours.NomEtre + " attaque son espece favorite " + ev.NomEtre);
                            Herbivore herbi = (Herbivore)ev;
                            Carnivore carni = (Carnivore)etreVivantEnCours;
                            carni.seNourrir(herbi);
                            if (ev.VieActuelle <= 0)
                            {
                                nourrirUnCarnivore(actionDialog);
                            }
                        }
                    }

                    if (etreVivantEnCours.PointsActionActuels >= 4)
                    {
                        foreach (EtreVivant ev in cases.ListEVCase)
                        {
                            if (Convert.ToString(ev.GetType().BaseType) == "GestionEco.Herbivore")
                            {
                                Console.WriteLine(etreVivantEnCours.NomEtre + " attaque " + ev.NomEtre);
                                Herbivore herbi = (Herbivore)ev;
                                Carnivore carni = (Carnivore)etreVivantEnCours;
                                carni.seNourrir(herbi);
                                if (ev.VieActuelle <= 0)
                                {
                                    nourrirUnCarnivore(actionDialog);
                                }
                            }
                        }
                    }

                }

                // --------------------- test a modifier ----------------
                // --------------------- test a modifier ----------------
                // --------------------- test a modifier ----------------
                // --------------------- test a modifier ----------------




                if (etreVivantEnCours.GetType().BaseType.Name.ToString().Equals("Herbivore"))
                {
                    nourrirUnHerbivore(actionDialog);

                }

                desaltererUnIndividus(actionDialog);

                etreVivantEnCours.retraitPoints(1);


                etreVivantEnCours.affichageConsole();
                indexDeIndividusCourant++;

            }


        }

        public static void deplacerUnIndividus(List<string> actionDialog)
        {
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);

            Case laCaseSource = etreVivantEnCours.CasePosition;

            Case laCaseCible;

            if ((((int)(etreVivantEnCours.CasePosition.Position.X / (etreVivantEnCours.CasePosition.TextureCase.Width))) + 1) >= lePlateau.LesCases.Count)
            {

                laCaseCible = lePlateau.LesCases.ElementAt(0).ElementAt((int)(etreVivantEnCours.CasePosition.Position.Y / (etreVivantEnCours.CasePosition.TextureCase.Height)));

            }
            else
            {
                laCaseCible = lePlateau.LesCases.ElementAt(((int)(etreVivantEnCours.CasePosition.Position.X / (etreVivantEnCours.CasePosition.TextureCase.Width))) + 1).ElementAt((int)(etreVivantEnCours.CasePosition.Position.Y / (etreVivantEnCours.CasePosition.TextureCase.Height)));
            }

            laCaseSource.ListEVCase.Remove(etreVivantEnCours);
            laCaseCible.ListEVCase.Add(etreVivantEnCours);
            actionDialog.Add(etreVivantEnCours.affichageConsole() + " : deplacement");
        }

        public static void nourrirUnCarnivore(List<string> actionDialog)
        {
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);

            Case caseIndividuCourant = etreVivantEnCours.CasePosition;
            foreach (EtreVivant ev in caseIndividuCourant.ListEVCase)
            {
                if ((ev.GetType() == etreVivantEnCours.GetType()))
                {
                    int faim = ev.FaimActuelle;
                    ev.nourrir(10, etreVivantEnCours);
                    actionDialog.Add("Etre vivant : " + ev.NomEtre + " nourris. Sa faim passe de :" + faim + " à " + ev.FaimActuelle);
                }
            }


            actionDialog.Add(etreVivantEnCours.affichageConsole() + " : nourris");
        }

        public static void nourrirUnHerbivore(List<string> actionDialog)
        {
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            Case caseIndividuCourant = etreVivantEnCours.CasePosition;

            //On parcour les EV de la case, si on a un vegetal, on sort 
            foreach (EtreVivant ev in caseIndividuCourant.ListEVCase)
            {
                if (ev.GetType().BaseType.Name.ToString().Equals("Vegetal") && ev.GetType().Name.ToString().Equals(etreVivantEnCours.EspeceFavorite))
                {

                    Herbivore herbi = (Herbivore)etreVivantEnCours;
                    Vegetal veg = (Vegetal)ev;
                    herbi.seNourrir(veg);
                   actionDialog.Add(etreVivantEnCours.NomEtre + " a mangé son espece favorite " + ev.NomEtre);
                    break;
                }
            }

            if (etreVivantEnCours.PointsActionActuels >= 4)
            {
                foreach (EtreVivant ev in caseIndividuCourant.ListEVCase)
                {
                    if (ev.GetType().BaseType.Name.ToString().Equals("Vegetal"))
                    {
                        Herbivore herbi = (Herbivore)etreVivantEnCours;
                        Vegetal veg = (Vegetal)ev;
                        herbi.seNourrir(veg);
                        actionDialog.Add(etreVivantEnCours.NomEtre + " a mangé " + ev.NomEtre);
                        actionDialog.Add(etreVivantEnCours.FaimActuelle + "");
                        break;
                    }
                }
            }
        }

        public static void desaltererUnIndividus(List<string> actionDialog)
        {
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            Case laCaseSource = lePlateau.LesCases.ElementAt((int)(etreVivantEnCours.CasePosition.Position.X / (etreVivantEnCours.CasePosition.TextureCase.Width))).ElementAt((int)(etreVivantEnCours.CasePosition.Position.Y / (etreVivantEnCours.CasePosition.TextureCase.Height)));

            if (laCaseSource.Terrain.QteEauActuelle > 0)
            {
                //int aboire = laCaseSource.Terrain.QteEauActuelle;
                int aboire = 0;
                if (laCaseSource.Terrain.QteEauActuelle <= (etreVivantEnCours.SoifMax - etreVivantEnCours.SoifActuelle))
                {
                    aboire = laCaseSource.Terrain.QteEauActuelle;
                    laCaseSource.Terrain.QteEauActuelle = 0;

                }
                else
                {
                    laCaseSource.Terrain.QteEauActuelle -= (etreVivantEnCours.SoifMax - etreVivantEnCours.SoifActuelle);
                    aboire = etreVivantEnCours.SoifMax - etreVivantEnCours.SoifActuelle;
                }

                etreVivantEnCours.boire(aboire);

                actionDialog.Add(etreVivantEnCours.affichageConsole() + " : desaltere de :" + aboire + " eau");
            }
            else
            {
                if (etreVivantEnCours.SoifActuelle >= etreVivantEnCours.SoifMax)
                {
                    etreVivantEnCours.VieActuelle -= 15;
                }

                actionDialog.Add(etreVivantEnCours.affichageConsole() + " : plus deau sur le terrain, impossible de se desalterer");
            }


        }

        public static void tuerUnIndividus(List<string> actionDialog)
        {

            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            Case laCaseSource = lePlateau.LesCases.ElementAt((int)(etreVivantEnCours.CasePosition.Position.X / etreVivantEnCours.CasePosition.TextureCase.Width)).ElementAt((int)(etreVivantEnCours.CasePosition.Position.Y / etreVivantEnCours.CasePosition.TextureCase.Height));
            laCaseSource.ListEVCase.Remove(etreVivantEnCours);
            laListeEcosysteme.Remove(etreVivantEnCours);
            actionDialog.Add(etreVivantEnCours.NomEtre + " : mort");
        }

        public static Vector2 trouverUneCible()
        {
            Vector2 position;
            Vector2 posiEtreVivantActuel;
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            position = etreVivantEnCours.CasePosition.Position;
            posiEtreVivantActuel.X = Convert.ToInt32(etreVivantEnCours.CasePosition.Position.X / 400);
            posiEtreVivantActuel.Y = Convert.ToInt32(etreVivantEnCours.CasePosition.Position.Y / 400);

            Vector2 posiMax;
            Vector2 posiMin;
            List<EtreVivant> laListeCibles = new List<EtreVivant>();

            posiMin.X = posiEtreVivantActuel.X - etreVivantEnCours.Vue;
            if (posiMin.X < 0)
            {
                posiMin.X = 0;
            }

            posiMin.Y = posiEtreVivantActuel.Y - etreVivantEnCours.Vue;
            if (posiMin.Y < 0)
            {
                posiMin.Y = 0;
            }

            posiMax.X = posiEtreVivantActuel.X + etreVivantEnCours.Vue;
            if (posiMax.X > taille[0])
            {
                posiMax.X = taille[0];
            }

            posiMax.Y = posiEtreVivantActuel.Y + etreVivantEnCours.Vue;
            if (posiMax.Y > taille[1])
            {
                posiMax.Y = taille[1];
            }

            for (int i = Convert.ToInt32(posiMin.X); i < Convert.ToInt32(posiMax.X); i++)
            {
                for (int j = Convert.ToInt32(posiMin.Y); j < Convert.ToInt32(posiMax.Y); j++)
                {
                    foreach (EtreVivant ev in lePlateau.LesCases.ElementAt(i).ElementAt(j).ListEVCase)
                    {
                        if (ev.GetType().Name.ToString() == etreVivantEnCours.EspeceFavorite)
                        {
                            laListeCibles.Add(ev);
                        }
                    }
                }
            }

            if (laListeCibles.Count == 0)
            {
                for (int i = Convert.ToInt32(posiMin.X); i < Convert.ToInt32(posiMax.X); i++)
                {
                    for (int j = Convert.ToInt32(posiMin.Y); j < Convert.ToInt32(posiMax.Y); j++)
                    {
                        foreach (EtreVivant ev in lePlateau.LesCases.ElementAt(i).ElementAt(j).ListEVCase)
                        {
                            if (etreVivantEnCours.GetType().BaseType.Name.ToString() == "Carnivore")
                            {
                                if (ev.GetType().BaseType.Name.ToString() == "Herbivore")
                                {
                                    laListeCibles.Add(ev);
                                }
                            }
                            else
                            {
                                if (ev.GetType().BaseType.Name.ToString() == "Vegetal")
                                {
                                    laListeCibles.Add(ev);
                                }
                            }
                        }
                    }
                }
            }

            // --------------------------------------- DIJKSTRA -------------------------------------
            // --------------------------------------- DIJKSTRA -------------------------------------
            // --------------------------------------- DIJKSTRA -------------------------------------
            if (laListeCibles.Count != 0)
            {

                List<List<Vertex>> tableauLesCases = new List<List<Vertex>>();
                for (int i = 0; i < laListeCibles.Count; i++)
                {
                    Vertex cible = new Vertex(Convert.ToInt32(laListeCibles.ElementAt(i).CasePosition.Position.X / 400), Convert.ToInt32(laListeCibles.ElementAt(i).CasePosition.Position.Y / 400), "Cible");
                    Vertex depart = new Vertex(Convert.ToInt32(etreVivantEnCours.CasePosition.Position.X / 400), Convert.ToInt32(etreVivantEnCours.CasePosition.Position.Y / 400), "depart");
                    Vertex temp;
                    for (int x = Convert.ToInt32(posiMin.X); x < Convert.ToInt32(posiMax.X); x++)
                    {
                        List<Vertex> lesCases = new List<Vertex>();
                        for (int y = Convert.ToInt32(posiMin.Y); y < Convert.ToInt32(posiMax.Y); y++)
                        {

                            temp = new Vertex(x, y, "" + x + "" + y);
                            lesCases.Add(temp);
                        }
                        tableauLesCases.Add(lesCases);

                    }
                    double cout = 1;

                    for (int x = 1; x < tableauLesCases.Count - 1; x++)
                    {

                        for (int y = 1; y < tableauLesCases.ElementAt(x).Count - 1; y++)
                        {

                            Vertex point1 = tableauLesCases.ElementAt(x).ElementAt(y);

                            Vertex point2 = tableauLesCases.ElementAt(x - 1).ElementAt(y);
                            point1.lier_avec(point2, cout);
                            point2.lier_avec(point1, cout);

                            point2 = tableauLesCases.ElementAt(x - 1).ElementAt(y - 1);
                            point1.lier_avec(point2, cout);
                            point2.lier_avec(point1, cout);

                            point2 = tableauLesCases.ElementAt(x).ElementAt(y - 1);
                            point1.lier_avec(point2, cout);
                            point2.lier_avec(point1, cout);

                            point2 = tableauLesCases.ElementAt(x + 1).ElementAt(y - 1);
                            point1.lier_avec(point2, cout);
                            point2.lier_avec(point1, cout);

                            point2 = tableauLesCases.ElementAt(x + 1).ElementAt(y);
                            point1.lier_avec(point2, cout);
                            point2.lier_avec(point1, cout);

                            point2 = tableauLesCases.ElementAt(x + 1).ElementAt(y + 1);
                            point1.lier_avec(point2, cout);
                            point2.lier_avec(point1, cout);

                            point2 = tableauLesCases.ElementAt(x).ElementAt(y + 1);
                            point1.lier_avec(point2, cout);
                            point2.lier_avec(point1, cout);

                            point2 = tableauLesCases.ElementAt(x - 1).ElementAt(y + 1);
                            point1.lier_avec(point2, cout);
                            point2.lier_avec(point1, cout);
                        }
                    }

                    for (int y = 1; y < tableauLesCases.ElementAt(0).Count - 1; y++)
                    {

                        Vertex point1 = tableauLesCases.ElementAt(0).ElementAt(y - 1);

                        Vertex point2 = tableauLesCases.ElementAt(0).ElementAt(y);
                        point1.lier_avec(point2, cout);
                        point2.lier_avec(point1, cout);

                        point1 = tableauLesCases.ElementAt(tableauLesCases.Count - 1).ElementAt(y - 1);

                        point2 = tableauLesCases.ElementAt(tableauLesCases.Count - 1).ElementAt(y);
                        point1.lier_avec(point2, cout);
                        point2.lier_avec(point1, cout);
                    }

                    for (int x = 1; x < tableauLesCases.Count - 1; x++)
                    {

                        Vertex point1 = tableauLesCases.ElementAt(x - 1).ElementAt(0);

                        Vertex point2 = tableauLesCases.ElementAt(x).ElementAt(0);
                        point1.lier_avec(point2, cout);
                        point2.lier_avec(point1, cout);

                        point1 = tableauLesCases.ElementAt(x - 1).ElementAt(tableauLesCases.ElementAt(x).Count - 1);

                        point2 = tableauLesCases.ElementAt(x).ElementAt(tableauLesCases.ElementAt(x).Count - 1);
                        point1.lier_avec(point2, cout);
                        point2.lier_avec(point1, cout);
                    }

                    List<Vertex> cases = new List<Vertex>();
                    for (int x = 0; x < tableauLesCases.Count; x++)
                    {
                        for (int y = 0; y < tableauLesCases.ElementAt(x).Count; y++)
                        {
                            cases.Add(tableauLesCases.ElementAt(x).ElementAt(y));
                        }
                    }

                    Dijkstra dij = new Dijkstra(cases);


                    //List<Vertex> Chemin =dij.trouver_chemin(depart, cible);

                }
            }

            // --------------------------------------- DIJKSTRA -------------------------------------
            // --------------------------------------- DIJKSTRA -------------------------------------
            // --------------------------------------- DIJKSTRA -------------------------------------
            return position;
        }

        public static int distanceAParcourir(EtreVivant cible)
        {
            int distance = -1;
            Vector2 posiEtreVivantActuel;
            Vector2 posiCible;
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            posiEtreVivantActuel.X = Convert.ToInt32(etreVivantEnCours.CasePosition.Position.X / 400);
            posiEtreVivantActuel.Y = Convert.ToInt32(etreVivantEnCours.CasePosition.Position.Y / 400);
            posiCible.X = Convert.ToInt32(cible.CasePosition.Position.X / 400);
            posiCible.Y = Convert.ToInt32(cible.CasePosition.Position.Y / 400);
            int i = 0;
            if (posiEtreVivantActuel == posiCible)
            {
                distance = 0;
            }
            else
            {
                while (posiEtreVivantActuel != posiCible && i < 6)
                {
                    if (posiEtreVivantActuel.X > posiCible.X && posiEtreVivantActuel.Y > posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantActuel.X) - 1).ElementAt(Convert.ToInt32(posiEtreVivantActuel.Y) - 1).Terrain.Type.ToString() != "Mer")
                    {
                        distance++;
                        posiEtreVivantActuel.X--;
                        posiEtreVivantActuel.Y--;
                    }
                    else if (posiEtreVivantActuel.X < posiCible.X && posiEtreVivantActuel.Y < posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantActuel.X) + 1).ElementAt(Convert.ToInt32(posiEtreVivantActuel.Y) + 1).Terrain.Type.ToString() != "Mer")
                    {
                        distance++;
                        posiEtreVivantActuel.X++;
                        posiEtreVivantActuel.Y++;
                    }
                    else if (posiEtreVivantActuel.X < posiCible.X && posiEtreVivantActuel.Y == posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantActuel.X) - 1).ElementAt(Convert.ToInt32(posiEtreVivantActuel.Y)).Terrain.Type.ToString() != "Mer")
                    {
                        distance++;
                        posiEtreVivantActuel.X--;
                    }
                    else if (posiEtreVivantActuel.X > posiCible.X && posiEtreVivantActuel.Y == posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantActuel.X) + 1).ElementAt(Convert.ToInt32(posiEtreVivantActuel.Y)).Terrain.Type.ToString() != "Mer")
                    {
                        distance++;
                        posiEtreVivantActuel.X++;
                    }
                    else if (posiEtreVivantActuel.X == posiCible.X && posiEtreVivantActuel.Y < posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantActuel.X)).ElementAt(Convert.ToInt32(posiEtreVivantActuel.Y) - 1).Terrain.Type.ToString() != "Mer")
                    {
                        distance++;
                        posiEtreVivantActuel.Y--;
                    }
                    else if (posiEtreVivantActuel.X == posiCible.X && posiEtreVivantActuel.Y > posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantActuel.X)).ElementAt(Convert.ToInt32(posiEtreVivantActuel.Y) + 1).Terrain.Type.ToString() != "Mer")
                    {
                        distance++;
                        posiEtreVivantActuel.Y++;
                    }
                    else if (posiEtreVivantActuel.X < posiCible.X && posiEtreVivantActuel.Y > posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantActuel.X) + 1).ElementAt(Convert.ToInt32(posiEtreVivantActuel.Y) - 1).Terrain.Type.ToString() != "Mer")
                    {
                        distance++;
                        posiEtreVivantActuel.X++;
                        posiEtreVivantActuel.Y--;
                    }
                    else if (posiEtreVivantActuel.X > posiCible.X && posiEtreVivantActuel.Y < posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantActuel.X) - 1).ElementAt(Convert.ToInt32(posiEtreVivantActuel.Y) + 1).Terrain.Type.ToString() != "Mer")
                    {
                        distance++;
                        posiEtreVivantActuel.X--;
                        posiEtreVivantActuel.Y++;
                    }
                    i++;
                }
                if (i < 6)
                {
                    distance += 1;
                }
            }

            return distance;
        }

        public static int tailleChemin(EtreVivant cible)
        {
            int distance;
            distance = -1;
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            Vector2 posiEtreVivantEnCours = etreVivantEnCours.CasePosition.Position;
            Vector2 posiCible = cible.CasePosition.Position;
            while (posiEtreVivantEnCours != posiCible)
            {
                if (posiEtreVivantEnCours.X > posiCible.X && posiEtreVivantEnCours.Y > posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantEnCours.X) / 400 - 1).ElementAt(Convert.ToInt32(posiEtreVivantEnCours.Y) / 400 - 1).Terrain.Type != "Mer")
                {
                    distance++;
                    posiEtreVivantEnCours.X--;
                    posiEtreVivantEnCours.Y--;
                }
                else if (posiEtreVivantEnCours.X < posiCible.X && posiEtreVivantEnCours.Y < posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantEnCours.X) / 400 + 1).ElementAt(Convert.ToInt32(posiEtreVivantEnCours.Y) / 400 + 1).Terrain.Type != "Mer")
                {
                    distance++;
                    posiEtreVivantEnCours.X++;
                    posiEtreVivantEnCours.Y++;
                }
                else if (posiEtreVivantEnCours.X < posiCible.X && posiEtreVivantEnCours.Y == posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantEnCours.X) / 400 + 1).ElementAt(Convert.ToInt32(posiEtreVivantEnCours.Y)).Terrain.Type != "Mer")
                {
                    distance++;
                    posiEtreVivantEnCours.X--;
                }
                else if (posiEtreVivantEnCours.X > posiCible.X && posiEtreVivantEnCours.Y == posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantEnCours.X) / 400 - 1).ElementAt(Convert.ToInt32(posiEtreVivantEnCours.Y)).Terrain.Type != "Mer")
                {
                    distance++;
                    posiEtreVivantEnCours.X++;
                }
                else if (posiEtreVivantEnCours.X == posiCible.X && posiEtreVivantEnCours.Y < posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantEnCours.X)).ElementAt(Convert.ToInt32(posiEtreVivantEnCours.Y) / 400 + 1).Terrain.Type != "Mer")
                {
                    distance++;
                    posiEtreVivantEnCours.Y--;
                }
                else if (posiEtreVivantEnCours.X == posiCible.X && posiEtreVivantEnCours.Y > posiCible.Y && lePlateau.LesCases.ElementAt(Convert.ToInt32(posiEtreVivantEnCours.X)).ElementAt(Convert.ToInt32(posiEtreVivantEnCours.Y) / 400 - 1).Terrain.Type != "Mer")
                {
                    distance++;
                    posiEtreVivantEnCours.Y++;
                }
            }
            if (posiEtreVivantEnCours == posiCible)
            {
                distance = 0;
            }

            return distance;
        }

        public static Boolean miseAjourEtat(List<string> actionDialog)
        {
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            etreVivantEnCours.FaimActuelle -= etreVivantEnCours.CoeffFaim;
            etreVivantEnCours.SoifActuelle -= etreVivantEnCours.CoeffSoif;
            etreVivantEnCours.vieillir();
            Boolean retour = false;

            if (etreVivantEnCours.SoifActuelle <= 0)
            {
                tuerUnIndividus(actionDialog);
            }
            else if (etreVivantEnCours.FaimActuelle <= 0 && etreVivantEnCours.GetType().BaseType.Name.ToString().Equals("Vegetal") == false)
            {
                tuerUnIndividus(actionDialog);
            }
            else if (etreVivantEnCours.Age >= etreVivantEnCours.AgeMax)
            {
                tuerUnIndividus(actionDialog);
            }
            else if (etreVivantEnCours.VieActuelle <= 0)
            {
                tuerUnIndividus(actionDialog);
            }
            else
            {
                etreVivantEnCours.PointsActionActuels = 6;
                etreVivantEnCours.seRegenerer();
                // ajouter l'incrementation du nombre de tours avant reprod;
                retour = true;
            }
            return retour;
        }

        #region Priorites
        public static int definirPrioriteFaim()
        {
            int priorite = 0;
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            if (etreVivantEnCours.FaimActuelle > etreVivantEnCours.FaimMax * 0.75)
            {
                priorite = 2;
            }
            else if (etreVivantEnCours.FaimActuelle <= etreVivantEnCours.FaimMax * 0.75 && etreVivantEnCours.FaimActuelle > etreVivantEnCours.FaimMax * 0.5)
            {
                priorite = 3;
            }
            else if (etreVivantEnCours.FaimActuelle <= etreVivantEnCours.FaimMax * 0.5 && etreVivantEnCours.FaimActuelle > etreVivantEnCours.FaimMax * 0.25)
            {
                priorite = 4;
            }
            else if (etreVivantEnCours.FaimActuelle <= etreVivantEnCours.FaimMax * 0.25 && etreVivantEnCours.FaimActuelle > etreVivantEnCours.FaimMax * 0.15)
            {
                priorite = 5;
            }
            return priorite;
        }

        public static int definirPrioriteSoif()
        {
            int priorite = 0;
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);
            if (etreVivantEnCours.SoifActuelle > etreVivantEnCours.SoifMax * 0.75)
            {
                priorite = 2;
            }
            else if (etreVivantEnCours.SoifActuelle <= etreVivantEnCours.SoifMax * 0.75 && etreVivantEnCours.SoifActuelle > etreVivantEnCours.SoifMax * 0.5)
            {
                priorite = 3;
            }
            else if (etreVivantEnCours.SoifActuelle <= etreVivantEnCours.SoifMax * 0.5 && etreVivantEnCours.SoifActuelle > etreVivantEnCours.SoifMax * 0.25)
            {
                priorite = 4;
            }
            else if (etreVivantEnCours.SoifActuelle <= etreVivantEnCours.SoifMax * 0.25 && etreVivantEnCours.SoifActuelle > etreVivantEnCours.SoifMax * 0.15)
            {
                priorite = 5;
            }
            return priorite;
        }

        public static int definirPrioriteReproduction()
        {
            int priorite = 0;
            EtreVivant etreVivantEnCours = laListeEcosysteme.ElementAt(indexDeIndividusCourant);

            if (etreVivantEnCours.NbTourAvantReprod == 0 && etreVivantEnCours.Age >= etreVivantEnCours.Majorite)
            {
                priorite = 4;
            }
            return priorite;
        }
        #endregion
    }
}
